/******************************************************************************
* Copyright (c) 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
****************************************************************************/
package org.eclipse.gmf.runtime.doclet.proxies;
import java.util.ArrayList;
import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.ConstructorDoc;
import com.sun.javadoc.Doc;
import com.sun.javadoc.ExecutableMemberDoc;
import com.sun.javadoc.FieldDoc;
import com.sun.javadoc.MemberDoc;
import com.sun.javadoc.MethodDoc;
import com.sun.javadoc.PackageDoc;
import com.sun.javadoc.ParamTag;
import com.sun.javadoc.Parameter;
import com.sun.javadoc.ProgramElementDoc;
import com.sun.javadoc.RootDoc;
import com.sun.javadoc.SeeTag;
import com.sun.javadoc.SerialFieldTag;
import com.sun.javadoc.Tag;
import com.sun.javadoc.ThrowsTag;
import com.sun.javadoc.Type;
/**
* Factory for proxy objects. Generate proxies for Object, typed Object, or collection.
* The factory is smart enough to always return the most derived proxy for a given element.
* The factory will always return the same proxy for a given object to wrap.
*/
public class ProxyFactory {
private ProxyRegistry proxyRegistry = null;
private static ProxyFactory instance = null;
public static ProxyFactory getInstance() {
if (instance == null) {
instance = new ProxyFactory();
}
return instance;
}
/*
* DocProxy Proxies
*/
public DocProxy[] createDocProxies(Doc docs[]) {
ArrayList docProxies = new ArrayList();
for (int i = 0; i < docs.length; i++) {
Doc doc = docs[i];
docProxies.add(createDocProxy(doc));
}
return (DocProxy[]) docProxies.toArray(new DocProxy[0]);
}
public DocProxy createDocProxy(Object object) {
DocProxy docProxy = null;
if (object instanceof DocProxy) {
docProxy = (DocProxy) object;
} else {
if (object instanceof Doc) {
docProxy = createDocProxy((Doc) object);
}
}
return docProxy;
}
public DocProxy createDocProxy(Doc doc) {
DocProxy proxy = null;
if (doc != null) {
proxy = (DocProxy) getProxyRegistry().getProxyForObject(doc);
if (proxy == null) {
if (doc instanceof PackageDoc) {
proxy = createPackageDocProxy((PackageDoc) doc);
} else if (doc instanceof ProgramElementDoc) {
proxy = createProgramElementDocProxy((ProgramElementDoc) doc);
} else if (doc instanceof RootDoc) {
proxy = createRootDocProxy((RootDoc) doc);
} else {
proxy = new DocProxy(doc);
ProxyFactory.getInstance().getProxyRegistry()
.registerProxy(doc, proxy);
}
}
}
return proxy;
}
/*
* PackageDoc Proxies
*/
public PackageDocProxy[] createPackageDocProxies(PackageDoc packageDocs[]) {
ArrayList packageDocProxies = new ArrayList();
for (int i = 0; i < packageDocs.length; i++) {
PackageDoc packageDoc = packageDocs[i];
packageDocProxies.add(createPackageDocProxy(packageDoc));
}
return (PackageDocProxy[]) packageDocProxies
.toArray(new PackageDocProxy[0]);
}
public PackageDocProxy createPackageDocProxy(Object object) {
PackageDocProxy packageDocProxy = null;
if (object instanceof PackageDocProxy) {
packageDocProxy = (PackageDocProxy) object;
} else {
if (object instanceof PackageDoc) {
packageDocProxy = createPackageDocProxy((PackageDoc) object);
}
}
return packageDocProxy;
}
public PackageDocProxy createPackageDocProxy(PackageDoc packageDoc) {
PackageDocProxy proxy = null;
if (packageDoc != null) {
proxy = (PackageDocProxy) getProxyRegistry().getProxyForObject(
packageDoc);
if (proxy == null) {
proxy = new PackageDocProxy(packageDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
packageDoc, proxy);
}
}
return proxy;
}
/*
* ProgramElementDocProxy Proxies
*/
public ProgramElementDocProxy[] createProgramElementDocProxies(
ProgramElementDoc programElementDocs[]) {
ArrayList programElementDocProxies = new ArrayList();
for (int i = 0; i < programElementDocs.length; i++) {
ProgramElementDoc programElementDoc = programElementDocs[i];
programElementDocProxies
.add(createProgramElementDocProxy(programElementDoc));
}
return (ProgramElementDocProxy[]) programElementDocProxies
.toArray(new ProgramElementDocProxy[0]);
}
public ProgramElementDocProxy createProgramElementDocProxy(Object object) {
ProgramElementDocProxy programElementDocProxy = null;
if (object instanceof ProgramElementDocProxy) {
programElementDocProxy = (ProgramElementDocProxy) object;
} else {
if (object instanceof ProgramElementDoc) {
programElementDocProxy = createProgramElementDocProxy((ProgramElementDoc) object);
}
}
return programElementDocProxy;
}
public ProgramElementDocProxy createProgramElementDocProxy(
ProgramElementDoc programElementDoc) {
ProgramElementDocProxy proxy = null;
if (programElementDoc != null) {
proxy = (ProgramElementDocProxy) getProxyRegistry()
.getProxyForObject(programElementDoc);
if (proxy == null) {
if (programElementDoc instanceof ClassDoc) {
proxy = createClassDocProxy((ClassDoc) programElementDoc);
} else if (programElementDoc instanceof MemberDoc) {
proxy = createMemberDocProxy((MemberDoc) programElementDoc);
} else {
proxy = new ProgramElementDocProxy(programElementDoc);
ProxyFactory.getInstance().getProxyRegistry()
.registerProxy(programElementDoc, proxy);
}
}
}
return proxy;
}
/*
* RootDoc Proxies
*/
public RootDocProxy createRootDocProxy(Object object) {
RootDocProxy rootDocProxy = null;
if (object instanceof RootDocProxy) {
rootDocProxy = (RootDocProxy) object;
} else {
if (object instanceof RootDoc) {
rootDocProxy = createRootDocProxy((RootDoc) object);
}
}
return rootDocProxy;
}
public RootDocProxy createRootDocProxy(RootDoc rootDoc) {
RootDocProxy proxy = null;
if (rootDoc != null) {
proxy = (RootDocProxy) getProxyRegistry()
.getProxyForObject(rootDoc);
if (proxy == null) {
proxy = new RootDocProxy(rootDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
rootDoc, proxy);
}
}
return proxy;
}
/*
* ClassDoc Proxies
*/
public ClassDocProxy[] createClassDocProxies(ClassDoc classDocs[]) {
ArrayList classDocProxies = new ArrayList();
for (int i = 0; i < classDocs.length; i++) {
ClassDoc classDoc = classDocs[i];
classDocProxies.add(createClassDocProxy(classDoc));
}
return (ClassDocProxy[]) classDocProxies.toArray(new ClassDocProxy[0]);
}
public ClassDocProxy createClassDocProxy(Object object) {
ClassDocProxy classDocProxy = null;
if (object instanceof ClassDocProxy) {
classDocProxy = (ClassDocProxy) object;
} else {
if (object instanceof ClassDoc) {
classDocProxy = createClassDocProxy((ClassDoc) object);
}
}
return classDocProxy;
}
public ClassDocProxy createClassDocProxy(ClassDoc classDoc) {
ClassDocProxy proxy = null;
if (classDoc != null) {
proxy = (ClassDocProxy) getProxyRegistry().getProxyForObject(
classDoc);
if (proxy == null) {
proxy = new ClassDocProxy(classDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
classDoc, proxy);
}
}
return proxy;
}
/*
* MemberDoc Proxies
*/
public MemberDocProxy[] createMemberDocProxies(MemberDoc memberDocs[]) {
ArrayList memberDocProxies = new ArrayList();
for (int i = 0; i < memberDocs.length; i++) {
MemberDoc memberDoc = memberDocs[i];
memberDocProxies.add(createMemberDocProxy(memberDoc));
}
return (MemberDocProxy[]) memberDocProxies
.toArray(new MemberDocProxy[0]);
}
public MemberDocProxy createMemberDocProxy(Object object) {
MemberDocProxy memberDocProxy = null;
if (object instanceof MemberDocProxy) {
memberDocProxy = (MemberDocProxy) object;
} else {
if (object instanceof MemberDoc) {
memberDocProxy = createMemberDocProxy((MemberDoc) object);
}
}
return memberDocProxy;
}
public MemberDocProxy createMemberDocProxy(MemberDoc memberDoc) {
MemberDocProxy proxy = null;
if (memberDoc != null) {
proxy = (MemberDocProxy) getProxyRegistry().getProxyForObject(
memberDoc);
if (proxy == null) {
if (memberDoc instanceof ExecutableMemberDoc) {
proxy = createExecutableMemberDocProxy((ExecutableMemberDoc) memberDoc);
} else if (memberDoc instanceof FieldDoc) {
proxy = createFieldDocProxy((FieldDoc) memberDoc);
} else {
proxy = new MemberDocProxy(memberDoc);
ProxyFactory.getInstance().getProxyRegistry()
.registerProxy(memberDoc, proxy);
}
}
}
return proxy;
}
/*
* ExecutableMemberDoc Proxies
*/
public ExecutableMemberDocProxy[] createExecutableMemberDocProxies(
ExecutableMemberDoc executableMemberDocs[]) {
ArrayList executableMemberDocProxies = new ArrayList();
for (int i = 0; i < executableMemberDocs.length; i++) {
ExecutableMemberDoc executableMemberDoc = executableMemberDocs[i];
executableMemberDocProxies
.add(createExecutableMemberDocProxy(executableMemberDoc));
}
return (ExecutableMemberDocProxy[]) executableMemberDocProxies
.toArray(new ExecutableMemberDocProxy[0]);
}
public ExecutableMemberDocProxy createExecutableMemberDocProxy(Object object) {
ExecutableMemberDocProxy executableMemberDocProxy = null;
if (object instanceof ExecutableMemberDocProxy) {
executableMemberDocProxy = (ExecutableMemberDocProxy) object;
} else {
if (object instanceof ExecutableMemberDoc) {
executableMemberDocProxy = createExecutableMemberDocProxy((ExecutableMemberDoc) object);
}
}
return executableMemberDocProxy;
}
public ExecutableMemberDocProxy createExecutableMemberDocProxy(
ExecutableMemberDoc executableMemberDoc) {
ExecutableMemberDocProxy proxy = null;
if (executableMemberDoc != null) {
proxy = (ExecutableMemberDocProxy) getProxyRegistry()
.getProxyForObject(executableMemberDoc);
if (proxy == null) {
if (executableMemberDoc instanceof ConstructorDoc) {
proxy = createConstructorDocProxy((ConstructorDoc) executableMemberDoc);
} else if (executableMemberDoc instanceof MethodDoc) {
proxy = createMethodDocProxy((MethodDoc) executableMemberDoc);
} else {
proxy = new ExecutableMemberDocProxy(executableMemberDoc);
ProxyFactory.getInstance().getProxyRegistry()
.registerProxy(executableMemberDoc, proxy);
}
}
}
return proxy;
}
/*
* FieldDoc Proxies
*/
public FieldDocProxy[] createFieldDocProxies(FieldDoc fieldDocs[]) {
ArrayList fieldDocProxies = new ArrayList();
for (int i = 0; i < fieldDocs.length; i++) {
FieldDoc fieldDoc = fieldDocs[i];
fieldDocProxies.add(createFieldDocProxy(fieldDoc));
}
return (FieldDocProxy[]) fieldDocProxies.toArray(new FieldDocProxy[0]);
}
public FieldDocProxy createFieldDocProxy(Object object) {
FieldDocProxy fieldDocProxy = null;
if (object instanceof FieldDocProxy) {
fieldDocProxy = (FieldDocProxy) object;
} else {
if (object instanceof FieldDoc) {
fieldDocProxy = createFieldDocProxy((FieldDoc) object);
}
}
return fieldDocProxy;
}
public FieldDocProxy createFieldDocProxy(FieldDoc fieldDoc) {
FieldDocProxy proxy = null;
if (fieldDoc != null) {
proxy = (FieldDocProxy) getProxyRegistry().getProxyForObject(
fieldDoc);
if (proxy == null) {
proxy = new FieldDocProxy(fieldDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
fieldDoc, proxy);
}
}
return proxy;
}
/*
* ContructorDoc Proxies
*/
public ConstructorDocProxy[] createConstructorDocProxies(
ConstructorDoc constructorDocs[]) {
ArrayList constructorDocProxies = new ArrayList();
for (int i = 0; i < constructorDocs.length; i++) {
ConstructorDoc constructorDoc = constructorDocs[i];
constructorDocProxies
.add(createConstructorDocProxy(constructorDoc));
}
return (ConstructorDocProxy[]) constructorDocProxies
.toArray(new ConstructorDocProxy[0]);
}
public ConstructorDocProxy createConstructorDocProxy(Object object) {
ConstructorDocProxy constructorDocProxy = null;
if (object instanceof ConstructorDocProxy) {
constructorDocProxy = (ConstructorDocProxy) object;
} else {
if (object instanceof ConstructorDoc) {
constructorDocProxy = createConstructorDocProxy((ConstructorDoc) object);
}
}
return constructorDocProxy;
}
public ConstructorDocProxy createConstructorDocProxy(
ConstructorDoc constructorDoc) {
ConstructorDocProxy proxy = null;
if (constructorDoc != null) {
proxy = (ConstructorDocProxy) getProxyRegistry().getProxyForObject(
constructorDoc);
if (proxy == null) {
proxy = new ConstructorDocProxy(constructorDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
constructorDoc, proxy);
}
}
return proxy;
}
/*
* MethodDoc Proxies
*/
public MethodDocProxy[] createMethodDocProxies(MethodDoc methodDocs[]) {
ArrayList methodDocProxies = new ArrayList();
for (int i = 0; i < methodDocs.length; i++) {
MethodDoc methodDoc = methodDocs[i];
methodDocProxies.add(createMethodDocProxy(methodDoc));
}
return (MethodDocProxy[]) methodDocProxies
.toArray(new MethodDocProxy[0]);
}
public MethodDocProxy createMethodDocProxy(Object object) {
MethodDocProxy methodDocProxy = null;
if (object instanceof MethodDocProxy) {
methodDocProxy = (MethodDocProxy) object;
} else {
if (object instanceof MethodDoc) {
methodDocProxy = createMethodDocProxy((MethodDoc) object);
}
}
return methodDocProxy;
}
public MethodDocProxy createMethodDocProxy(MethodDoc methodDoc) {
MethodDocProxy proxy = null;
if (methodDoc != null) {
proxy = (MethodDocProxy) getProxyRegistry().getProxyForObject(
methodDoc);
if (proxy == null) {
proxy = new MethodDocProxy(methodDoc);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
methodDoc, proxy);
}
}
return proxy;
}
/*
* Parameter Proxies
*/
public ParameterProxy[] createParameterProxies(Parameter parameters[]) {
ArrayList parameterProxies = new ArrayList();
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
parameterProxies.add(createParameterProxy(parameter));
}
return (ParameterProxy[]) parameterProxies
.toArray(new ParameterProxy[0]);
}
public ParameterProxy createParameterProxy(Object object) {
ParameterProxy parameterProxy = null;
if (object instanceof ParameterProxy) {
parameterProxy = (ParameterProxy) object;
} else {
if (object instanceof Parameter) {
parameterProxy = createParameterProxy((Parameter) object);
}
}
return parameterProxy;
}
public ParameterProxy createParameterProxy(Parameter parameter) {
ParameterProxy proxy = null;
if (parameter != null) {
proxy = (ParameterProxy) getProxyRegistry().getProxyForObject(
parameter);
if (proxy == null) {
proxy = new ParameterProxy(parameter);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
parameter, proxy);
}
}
return proxy;
}
/*
* Type Proxies
*/
public Proxy[] createTypeProxies(Type types[]) {
ArrayList typeProxies = new ArrayList();
for (int i = 0; i < types.length; i++) {
Type type = types[i];
typeProxies.add(createTypeProxy(type));
}
return (Proxy[]) typeProxies.toArray(new Proxy[0]);
}
public Proxy createTypeProxy(Object object) {
Proxy typeProxy = null;
if (object instanceof TypeProxy) {
typeProxy = (TypeProxy) object;
} else {
if (object instanceof Type) {
typeProxy = createTypeProxy((Type) object);
}
}
return typeProxy;
}
public Proxy createTypeProxy(Type type) {
Proxy proxy = null;
if (type != null) {
proxy = getProxyRegistry().getProxyForObject(type);
if (proxy == null) {
if (type instanceof ClassDoc) {
proxy = new ClassDocProxy((ClassDoc) type);
} else {
proxy = new TypeProxy(type);
}
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
type, proxy);
}
}
return proxy;
}
/*
* Tag Proxies
*/
public TagProxy[] createTagProxies(Tag tags[]) {
ArrayList tagProxies = new ArrayList();
for (int i = 0; i < tags.length; i++) {
Tag tag = tags[i];
tagProxies.add(createTagProxy(tag));
}
return (TagProxy[]) tagProxies.toArray(new TagProxy[0]);
}
public TagProxy createTagProxy(Object object) {
TagProxy tagProxy = null;
if (object instanceof TagProxy) {
tagProxy = (TagProxy) object;
} else {
if (object instanceof Tag) {
tagProxy = createTagProxy((Tag) object);
}
}
return tagProxy;
}
public TagProxy createTagProxy(Tag tag) {
TagProxy proxy = null;
if (tag != null) {
proxy = (TagProxy) getProxyRegistry().getProxyForObject(tag);
if (proxy == null) {
if (tag instanceof ParamTag) {
proxy = createParamTagProxy((ParamTag) tag);
} else if (tag instanceof SeeTag) {
proxy = createSeeTagProxy((SeeTag) tag);
} else if (tag instanceof SerialFieldTag) {
proxy = createSerialFieldTagProxy((SerialFieldTag) tag);
} else if (tag instanceof ThrowsTag) {
proxy = createThrowsTagProxy((ThrowsTag) tag);
} else {
proxy = new TagProxy(tag);
}
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
tag, proxy);
}
}
return proxy;
}
/*
* ParamTag Proxies
*/
public ParamTagProxy[] createParamTagProxies(ParamTag paramTags[]) {
ArrayList paramTagProxies = new ArrayList();
for (int i = 0; i < paramTags.length; i++) {
ParamTag paramTag = paramTags[i];
paramTagProxies.add(createParamTagProxy(paramTag));
}
return (ParamTagProxy[]) paramTagProxies
.toArray(new ParamTagProxy[0]);
}
public ParamTagProxy createParamTagProxy(Object object) {
ParamTagProxy paramTagProxy = null;
if (object instanceof ParamTagProxy) {
paramTagProxy = (ParamTagProxy) object;
} else {
if (object instanceof ParamTag) {
paramTagProxy = createParamTagProxy((ParamTag) object);
}
}
return paramTagProxy;
}
public ParamTagProxy createParamTagProxy(ParamTag paramTag) {
ParamTagProxy proxy = null;
if (paramTag != null) {
proxy = (ParamTagProxy) getProxyRegistry().getProxyForObject(
paramTag);
if (proxy == null) {
proxy = new ParamTagProxy(paramTag);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
paramTag, proxy);
}
}
return proxy;
}
/*
* SeeTag Proxies
*/
public SeeTagProxy[] createSeeTagProxies(SeeTag seeTags[]) {
ArrayList seeTagProxies = new ArrayList();
for (int i = 0; i < seeTags.length; i++) {
SeeTag seeTag = seeTags[i];
seeTagProxies.add(createSeeTagProxy(seeTag));
}
return (SeeTagProxy[]) seeTagProxies
.toArray(new SeeTagProxy[0]);
}
public SeeTagProxy createSeeTagProxy(Object object) {
SeeTagProxy seeTagProxy = null;
if (object instanceof SeeTagProxy) {
seeTagProxy = (SeeTagProxy) object;
} else {
if (object instanceof SeeTag) {
seeTagProxy = createSeeTagProxy((SeeTag) object);
}
}
return seeTagProxy;
}
public SeeTagProxy createSeeTagProxy(SeeTag seeTag) {
SeeTagProxy proxy = null;
if (seeTag != null) {
proxy = (SeeTagProxy) getProxyRegistry().getProxyForObject(
seeTag);
if (proxy == null) {
proxy = new SeeTagProxy(seeTag);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
seeTag, proxy);
}
}
return proxy;
}
/*
* ThrowsTag Proxies
*/
public ThrowsTagProxy[] createThrowsTagProxies(ThrowsTag throwsTags[]) {
ArrayList throwsTagProxies = new ArrayList();
for (int i = 0; i < throwsTags.length; i++) {
ThrowsTag throwsTag = throwsTags[i];
throwsTagProxies.add(createThrowsTagProxy(throwsTag));
}
return (ThrowsTagProxy[]) throwsTagProxies
.toArray(new ThrowsTagProxy[0]);
}
public ThrowsTagProxy createThrowsTagProxy(Object object) {
ThrowsTagProxy throwsTagProxy = null;
if (object instanceof ThrowsTagProxy) {
throwsTagProxy = (ThrowsTagProxy) object;
} else {
if (object instanceof ThrowsTag) {
throwsTagProxy = createThrowsTagProxy((ThrowsTag) object);
}
}
return throwsTagProxy;
}
public ThrowsTagProxy createThrowsTagProxy(ThrowsTag throwsTag) {
ThrowsTagProxy proxy = null;
if (throwsTag != null) {
proxy = (ThrowsTagProxy) getProxyRegistry().getProxyForObject(
throwsTag);
if (proxy == null) {
proxy = new ThrowsTagProxy(throwsTag);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
throwsTag, proxy);
}
}
return proxy;
}
/*
* SerialFieldTag Proxies
*/
public SerialFieldTagProxy[] createSerialFieldTagProxies(
SerialFieldTag serialFieldTags[]) {
ArrayList serialFieldTagProxies = new ArrayList();
for (int i = 0; i < serialFieldTags.length; i++) {
SerialFieldTag serialFieldTag = serialFieldTags[i];
serialFieldTagProxies
.add(createSerialFieldTagProxy(serialFieldTag));
}
return (SerialFieldTagProxy[]) serialFieldTagProxies
.toArray(new SerialFieldTagProxy[0]);
}
public SerialFieldTagProxy createSerialFieldTagProxy(Object object) {
SerialFieldTagProxy serialFieldTagProxy = null;
if (object instanceof SerialFieldTagProxy) {
serialFieldTagProxy = (SerialFieldTagProxy) object;
} else {
if (object instanceof SerialFieldTag) {
serialFieldTagProxy = createSerialFieldTagProxy((SerialFieldTag) object);
}
}
return serialFieldTagProxy;
}
public SerialFieldTagProxy createSerialFieldTagProxy(
SerialFieldTag serialFieldTag) {
SerialFieldTagProxy proxy = null;
if (serialFieldTag != null) {
proxy = (SerialFieldTagProxy) getProxyRegistry().getProxyForObject(
serialFieldTag);
if (proxy == null) {
proxy = new SerialFieldTagProxy(serialFieldTag);
ProxyFactory.getInstance().getProxyRegistry().registerProxy(
serialFieldTag, proxy);
}
}
return proxy;
}
private ProxyFactory() {
proxyRegistry = new ProxyRegistry();
}
/* package */ProxyRegistry getProxyRegistry() {
return proxyRegistry;
}
}
